home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 27 / CU Amiga Magazine's Super CD-ROM 27 (1998)(EMAP Images)(GB)[!][issue 1998-10].iso / CUCD / Programming / FreshBar / Source / Bar.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-06-15  |  11.1 KB  |  488 lines
  1. //*************************************************************************//
  2. // Filename:    Bar.cpp
  3. // Autor:       Christian Taulien of Strange Intelligence
  4. // Purpose:     Bar management and display implementation for FreshBar
  5. // Creation:    17. Mai 1998
  6. //*************************************************************************//
  7.  
  8. #include "global.h"
  9. #include "Bar.h"
  10. #include "WindowList.h"
  11. #include "TextMeasure.h"
  12. #include "VisualInfo.h"
  13.  
  14. #include <clib/exec_protos.h>
  15. #include <clib/gadtools_protos.h>
  16. #include <clib/graphics_protos.h>
  17.  
  18. #include <graphics/rastport.h>
  19.  
  20. extern "C" void NewList(struct List *list);
  21.  
  22. //******************************************************************//
  23. //******************************************************************//
  24. //
  25. //  BarNodeC
  26. //
  27. //******************************************************************//
  28. //******************************************************************//
  29. ULONG BarNodeC::m_ulNextFreeID = 0;
  30.  
  31. BarNodeC::BarNodeC(BarListC *arg_poBarList, char *arg_sName, ULONG arg_ulMaxValue)
  32. /*S*/
  33. {
  34.   TRACE("Konstruktor");
  35.   if (!arg_poBarList)
  36.   {
  37.     TRACE("Falscher Parameter!");
  38.     throw;
  39.   } // if
  40.  
  41.   // init the baseclassmembers
  42.   ln_Succ       = NULL;
  43.   ln_Pred       = NULL;
  44.   ln_Type       = NT_USER;
  45.   ln_Pri        = 0;
  46.  
  47.   // now our members
  48.   m_oName = arg_sName;
  49.   m_ulMaxValue = arg_ulMaxValue;
  50.   m_ulCurrentValue = 0;
  51.   m_bShowPercent = FALSE;
  52.   m_ulID = ++m_ulNextFreeID;
  53.   m_iPen = 3;
  54.   m_iBPen = 0;
  55.   m_eProgressMode = PM_Percent;
  56.  
  57.   AddTail(arg_poBarList, this);
  58. } // BarNodeC::BarNodeC()
  59. /*E*/
  60. BarNodeC::~BarNodeC()
  61. /*S*/
  62. {
  63.   TRACE("Destruktor");
  64.  
  65.   // delete the name
  66.   if (ln_Name)
  67.   {
  68.     delete ln_Name;
  69.   } // if
  70.  
  71.   // if the node is in a list
  72.   if (ln_Pred && ln_Succ)
  73.   {
  74.     Remove(this);
  75.   } // if
  76. }
  77. /*E*/
  78. BarNodeC *BarNodeC::getNext(void)
  79. /*S*/
  80. {
  81.   TRACE("getNext()");
  82.   if (ln_Succ && ln_Succ->ln_Succ)
  83.   {
  84.     return (BarNodeC *) ln_Succ;
  85.   } // if
  86.  
  87. return NULL;
  88. }
  89. /*E*/
  90. BarNodeC *BarNodeC::getPrev(void)
  91. /*S*/
  92. {
  93.   TRACE("getPrev()");
  94.   if (ln_Pred && ln_Pred->ln_Pred)
  95.   {
  96.     return (BarNodeC *) ln_Pred;
  97.   } // if
  98.  
  99. return NULL;
  100. }
  101. /*E*/
  102. void BarNodeC::drawBar(BarWindowNodeC *arg_poBWNode,
  103.                        TextMeasureC *arg_poTeMe,
  104.                        ULONG arg_ulPosX,
  105.                        ULONG arg_ulPosY,
  106.                        ULONG arg_ulBarBreite,
  107.                        ULONG arg_ulBreite,
  108.                        ULONG arg_ulHoehe)
  109. /*S*/
  110. { 
  111.   TRACE("Entry");
  112.   struct RastPort *poRPort = arg_poBWNode->getWindow()->RPort;
  113.   VisualInfoC oVI(arg_poBWNode->getWindow());
  114.   if (oVI.isOk())
  115.   {
  116.     TRACE("Visualinfo ok");
  117.  
  118.     // Bar-Title ausgeben
  119.     SetAPen(poRPort, 1);
  120.     Move(poRPort, arg_ulPosX, arg_ulPosY+arg_ulHoehe-5);
  121.     Text(poRPort, (char *) m_oName, m_oName.getLength());
  122.  
  123.     int iPosX = arg_ulPosX + arg_ulBreite - arg_ulBarBreite;
  124.     DrawBevelBox( poRPort,
  125.                   iPosX,
  126.                   arg_ulPosY,
  127.                   arg_ulBarBreite,
  128.                   arg_ulHoehe,
  129.                   GT_VisualInfo, (APTR) oVI,
  130.                   GTBB_Recessed, TRUE,
  131.                   TAG_DONE );
  132.  
  133.     fillBar(poRPort,
  134.             arg_poTeMe,
  135.             arg_ulPosX,
  136.             arg_ulPosY,
  137.             arg_ulBarBreite,
  138.             arg_ulBreite,
  139.             arg_ulHoehe);
  140.   } // if
  141. }
  142. /*E*/
  143. void BarNodeC::fillBar(struct RastPort *arg_poRPort,
  144.                        TextMeasureC *arg_poTeMe,
  145.                        ULONG arg_ulPosX,
  146.                        ULONG arg_ulPosY,
  147.                        ULONG arg_ulBarBreite,
  148.                        ULONG arg_ulBreite,
  149.                        ULONG arg_ulHoehe)
  150. /*S*/
  151. {
  152.   TRACE("Entry");
  153.   arg_ulPosX++;
  154.   arg_ulPosY++;
  155.   arg_ulBreite-=2;
  156.   arg_ulHoehe-=3;
  157.   arg_ulBarBreite-=3;
  158.  
  159.   // der CurrentValuef dar nicht kleiner als null sein
  160.   if (((int ) m_ulCurrentValue) < 0) m_ulCurrentValue = 0;
  161.   if (m_ulCurrentValue > m_ulMaxValue) m_ulCurrentValue = m_ulMaxValue;
  162.  
  163.   // Breite des blauen streifens berechnen
  164.   int iBreite = arg_ulBarBreite;
  165.   if (m_ulMaxValue)
  166.   {
  167.     iBreite = (arg_ulBarBreite*m_ulCurrentValue)/m_ulMaxValue;
  168.   } // if
  169.  
  170.   int iPosX = arg_ulPosX + arg_ulBreite - arg_ulBarBreite - 1;
  171.   SetAPen(arg_poRPort, m_iPen);
  172.   SetDrMd(arg_poRPort, JAM2);
  173.   RectFill(arg_poRPort,
  174.            iPosX,
  175.            arg_ulPosY,
  176.            iPosX + iBreite,
  177.            arg_ulPosY + arg_ulHoehe);
  178.  
  179.   if (iBreite!=arg_ulBarBreite)
  180.   {
  181.     SetAPen(arg_poRPort, m_iBPen);
  182.     RectFill(arg_poRPort,
  183.              iPosX + iBreite,
  184.              arg_ulPosY,
  185.              iPosX + arg_ulBarBreite,
  186.              arg_ulPosY + arg_ulHoehe);
  187.   } // if
  188.  
  189.   // nun den text ausgeben
  190.   SetAPen(arg_poRPort, 2);
  191.   SetDrMd(arg_poRPort, JAM1);
  192.   switch (m_eProgressMode)
  193.   {
  194.     case PM_Percent:
  195.       { // dummy scope
  196.         int iPercent = (m_ulCurrentValue * 100) / m_ulMaxValue;
  197.         StringC oBuf(10);
  198.         oBuf.formatString("%d%%", iPercent);
  199.         Move(arg_poRPort, iPosX + (arg_ulBarBreite-arg_poTeMe->getTextWidth(oBuf))/2, arg_ulPosY + arg_ulHoehe - 2);
  200.         Text(arg_poRPort, (char *) oBuf, oBuf.getLength());
  201.       } // dummy scope
  202.       break;
  203.     case PM_Absolute:
  204.       { // dummy scope
  205.         StringC oBuf(30);
  206.         oBuf.formatString("%d/%d", m_ulCurrentValue, m_ulMaxValue);
  207.         Move(arg_poRPort, iPosX + (arg_ulBarBreite-arg_poTeMe->getTextWidth(oBuf))/2, arg_ulPosY + arg_ulHoehe - 2);
  208.         Text(arg_poRPort, (char *) oBuf, oBuf.getLength());
  209.       } // dummy scope
  210.       break;
  211.   } // switch
  212. }
  213. /*E*/
  214.  
  215. //******************************************************************//
  216. //******************************************************************//
  217. //
  218. //  BarListC
  219. //
  220. //******************************************************************//
  221. //******************************************************************//
  222. BarListC::BarListC()
  223. /*S*/
  224. {
  225.   TRACE("Konstruktor");
  226.   NewList(this);
  227.   m_iBarWidth = 50;
  228. } // BarListC::BarListC()
  229. /*E*/
  230. BarListC::~BarListC()
  231. /*S*/
  232. {
  233.   TRACE("Destruktor");
  234.   removeAll();
  235.  
  236. } // BarListC::~FLXWacthListC()
  237. /*E*/
  238. void BarListC::removeAll()
  239. /*S*/
  240. {
  241.   TRACE("Entry");
  242.   // wenn die Liste nicht leer ist
  243.   if (!IsListEmpty(this))
  244.   {
  245.     BarNodeC *poNode;
  246.     while (poNode = (BarNodeC *) RemHead(this))
  247.     {
  248.       // Vorgaenger und Nachfolger auf null setzen
  249.       // weil mit RemHead schon removed und der Destruktor
  250.       // das bei nicht nulligen nodes nochmal machen wuerde.
  251.       poNode->ln_Succ = NULL;
  252.       poNode->ln_Pred = NULL;
  253.  
  254.       delete poNode;
  255.     } // while
  256.   } // if
  257.   NewList(this);
  258. }
  259. /*E*/
  260. void  BarListC::removeBar(ULONG arg_ulBarID)
  261. /*S*/
  262. {
  263.   TRACE("Entry");
  264.   // just find the node an delete it
  265.   BarNodeC *poNode = findBarNode(arg_ulBarID);
  266.   if (poNode)
  267.   {
  268.     delete poNode;
  269.   } // if
  270. }
  271. /*E*/
  272. BarNodeC *BarListC::addBar(char *arg_sName, ULONG arg_ulMaxValue)
  273. /*S*/
  274. {
  275.   TRACE("Entry");
  276.  
  277.   // neuen Balken erzeugen
  278.   BarNodeC *poNode = new BarNodeC(this, arg_sName, arg_ulMaxValue);
  279.   if (!poNode)
  280.   {
  281.     TRACE("Kein Speicher");
  282.     return FALSE;
  283.   } // if
  284. return poNode;
  285. }
  286. /*E*/
  287. BarNodeC *BarListC::findBarNode(ULONG arg_ulBarID)
  288. /*S*/
  289. {
  290.   TRACE("Entry");
  291.   BarNodeC *pNode = NULL;
  292.  
  293.   // wenn die Balkenliste nicht leer ist
  294.   if (!IsListEmpty(this))
  295.   {
  296.     pNode = (BarNodeC *) lh_Head;
  297.     do
  298.     {
  299.       if (pNode->m_ulID == arg_ulBarID)
  300.       {
  301.         return pNode;
  302.       } // if
  303.     } while (pNode = pNode->getNext());
  304.   } // if
  305.  
  306. return pNode;
  307. }
  308. /*E*/
  309. int BarListC::indexOf(BarNodeC *arg_pNode)
  310. /*S*/
  311. {
  312.   TRACE("Entry");
  313.  
  314.   // wenn die Balkenliste nicht leer ist
  315.   if (arg_pNode && !IsListEmpty(this))
  316.   {
  317.     int iIndex = 0;
  318.  
  319.     // hole 1. eintrag
  320.     BarNodeC *pNode = (BarNodeC *) lh_Head;
  321.     do
  322.     {
  323.       // wenn gefunden
  324.       if (pNode==arg_pNode)
  325.       {
  326.         return iIndex;
  327.       } // if
  328.  
  329.       iIndex++;
  330.     } while (pNode = pNode->getNext());
  331.   } // if
  332.  
  333. return -1;
  334. }
  335. /*E*/
  336. BarNodeC *BarListC::operator[](int arg_iIndex)
  337. /*S*/
  338. {
  339.   TRACE("ENTRY");
  340.  
  341.   BarNodeC *pNode = NULL;
  342.  
  343.   // wenn die Balken nicht leer ist
  344.   if (!IsListEmpty(this))
  345.   {
  346.     int index = 0;
  347.  
  348.     // hole 1. eintrag
  349.     pNode = (BarNodeC *) lh_Head;
  350.     do
  351.     {
  352.       // wenn i.ten eintrag erreicht
  353.       if (index == arg_iIndex)
  354.       {
  355.         return pNode;
  356.       } // if
  357.  
  358.       index++;
  359.     } while (pNode = pNode->getNext());
  360.   } // if
  361.  
  362. return pNode;
  363. }
  364. /*E*/
  365. int BarListC::getSize(void)
  366. /*S*/
  367. {
  368.   TRACE("Entry");
  369.   int iSize = 0;
  370.  
  371.   // wenn die Liste nicht leer ist
  372.   if (!IsListEmpty(this))
  373.   {
  374.     // hole 1. Eintrag
  375.     BarNodeC *pNode = (BarNodeC *) lh_Head;
  376.     for (iSize=1; pNode = pNode->getNext(); iSize++);
  377.   } // if
  378.  
  379. return iSize;
  380. }
  381. /*E*/
  382. int BarListC::getHeight(struct Screen *arg_poScreen)
  383. /*S*/
  384. {
  385.   TRACE("Entry");
  386.   // Objekt zum ermitteln der Text-hoehe
  387.   TextMeasureC oTeMe(arg_poScreen);
  388.  
  389. return getSize()*(oTeMe.getTextHeight()+7);
  390. }
  391. /*E*/
  392. int BarListC::getBarTitleWidth(struct Screen *arg_poScreen)
  393. /*S*/
  394. {
  395.   TRACE("Entry");
  396.   int iMaxWidth = 0;
  397.  
  398.   TextMeasureC oTeMe(arg_poScreen);
  399.  
  400.   // wenn die Liste nicht leer ist
  401.   if (!IsListEmpty(this))
  402.   {
  403.     // hole 1. Eintrag
  404.     BarNodeC *pNode = (BarNodeC *) lh_Head;
  405.  
  406.     do
  407.     {
  408.       iMaxWidth = SIFC_MAX(iMaxWidth, oTeMe.getTextWidth(pNode->getName()));
  409.     } while (pNode = pNode->getNext());
  410.   } // if
  411. return iMaxWidth+5;
  412. }
  413. /*E*/
  414. int BarListC::getWidth(struct Screen *arg_poScreen)
  415. /*S*/
  416. {
  417.   TRACE("Entry");
  418. return getBarTitleWidth(arg_poScreen) + m_iBarWidth;
  419. }
  420. /*E*/
  421. void BarListC::drawBars(BarWindowNodeC *arg_poBWNode, ULONG arg_ulPosX, ULONG arg_ulPosY)
  422. /*S*/
  423. { 
  424.   TRACE("Entry");
  425.   struct Window *poWindow = arg_poBWNode->getWindow();
  426.  
  427.   TextMeasureC oTeMe(poWindow->WScreen);
  428.   int iHoehe = oTeMe.getTextHeight()+6;
  429.   int iBreite = getWidth(poWindow->WScreen);
  430.  
  431.   struct TextFont *poTextFont = OpenFont(poWindow->WScreen->Font); // font oeffne
  432.   struct TextFont *poOldTextFont = poWindow->RPort->Font; // alten sichern
  433.   SetFont(poWindow->RPort, poTextFont); // neuen einstellen
  434.  
  435.   for (int i=0; i<getSize();i++)
  436.   { 
  437.     BarNodeC *poBarNode = operator[](i);
  438.     if (poBarNode)
  439.     {
  440.       poBarNode->drawBar(arg_poBWNode,
  441.                          &oTeMe,
  442.                          arg_ulPosX,
  443.                          arg_ulPosY+i*iHoehe,
  444.                          m_iBarWidth,
  445.                          iBreite,
  446.                          iHoehe-4);
  447.     } // if
  448.   } // for
  449.  
  450.   SetFont(poWindow->RPort, poOldTextFont);
  451.   CloseFont(poTextFont);
  452. }
  453. /*E*/
  454. void BarListC::fillBars(BarWindowNodeC *arg_poBWNode, ULONG arg_ulPosX, ULONG arg_ulPosY)
  455. /*S*/
  456. {
  457.   TRACE("Entry");
  458.   struct Window *poWindow = arg_poBWNode->getWindow();
  459.  
  460.   TextMeasureC oTeMe(poWindow->WScreen);
  461.   int iHoehe = oTeMe.getTextHeight()+6;
  462.   int iBreite = getWidth(poWindow->WScreen);
  463.  
  464.   struct TextFont *poTextFont = OpenFont(poWindow->WScreen->Font); // font oeffne
  465.   struct TextFont *poOldTextFont = poWindow->RPort->Font; // alten sichern
  466.   SetFont(poWindow->RPort, poTextFont); // neuen einstellen
  467.  
  468.   for (int i=0; i<getSize();i++)
  469.   {
  470.     BarNodeC *poBarNode = operator[](i);
  471.     if (poBarNode)
  472.     {
  473.       poBarNode->fillBar(poWindow->RPort,
  474.                          &oTeMe,
  475.                          arg_ulPosX,
  476.                          arg_ulPosY+i*iHoehe,
  477.                          m_iBarWidth,
  478.                          iBreite,
  479.                          iHoehe-4);
  480.     } // if
  481.   } // for
  482.  
  483.   SetFont(poWindow->RPort, poOldTextFont);
  484.   CloseFont(poTextFont);
  485. }
  486. /*E*/
  487.  
  488.